{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d77c3115",
   "metadata": {},
   "source": [
    "# 相对位置编码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c63af182",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "相对位置矩阵:\n",
      "tensor([[ 9, 10, 11, 12, 13],\n",
      "        [ 8,  9, 10, 11, 12],\n",
      "        [ 7,  8,  9, 10, 11],\n",
      "        [ 6,  7,  8,  9, 10],\n",
      "        [ 5,  6,  7,  8,  9]])\n",
      "相对位置嵌入参数形状: torch.Size([19, 16])\n",
      "序列长度为5的相对位置嵌入形状: torch.Size([5, 5, 16])\n",
      "输出形状: torch.Size([2, 5, 64])\n"
     ]
    }
   ],
   "source": [
    "import torch  # 导入PyTorch库\n",
    "import torch.nn as nn  # 导入PyTorch神经网络模块\n",
    "import math  # 导入数学函数库\n",
    "from torch.nn import functional as F  # 导入PyTorch函数式API\n",
    "\n",
    "# 定义相对位置编码模块，相对位置编码是有参数的，可训练的\n",
    "class RelativePositionEmbedding(nn.Module):\n",
    "    def __init__(self, max_seq_len: int, embedding_dim: int):\n",
    "        super().__init__()  # 调用父类初始化方法\n",
    "        self.max_seq_len = max_seq_len  # 最大序列长度\n",
    "        self.embedding_dim = embedding_dim  # 嵌入维度\n",
    "        # 创建相对位置嵌入参数，密集向量矩阵，max_seq_len * 2 - 1是相对位置矩阵的行数，embedding_dim是相对位置嵌入参数的列数\n",
    "        # 为什么是max_seq_len * 2 - 1是相对位置矩阵的行数\n",
    "        # 对于任意两个序列位置i和j，其相对位置为(i - j)，范围是[-(max_seq_len-1), max_seq_len-1]\n",
    "        # 这样一共包含2*max_seq_len-1种可能的相对位置，因此需要max_seq_len*2-1行来存储所有可能的相对位置嵌入\n",
    "        # 尺寸[max_seq_len * 2 - 1, embedding_dim],相对位置编码参数矩阵，随机初始化\n",
    "        self.relative_positions = nn.Parameter(torch.randn(max_seq_len * 2 - 1, embedding_dim))  # 创建所有可能相对位置的嵌入参数\n",
    "    \n",
    "    def forward(self, seq_len: int):\n",
    "        relative_positions_matrix = self._generate_relative_positions_matrix(seq_len)  # 生成相对位置矩阵\n",
    "        # relative_positions_matrix.shape = [seq_len, seq_len],relative_postion.shape = [seq_len * 2 - 1, embedding_dim]\n",
    "        # 使用F.embedding函数根据相对位置索引矩阵获取对应的嵌入向量\n",
    "        # relative_positions_matrix是一个形状为[seq_len, seq_len]的矩阵，每个元素表示序列中两个位置之间的相对距离（经过偏移，范围为0到max_seq_len*2-2）\n",
    "        # self.relative_positions是一个形状为[max_seq_len*2-1, embedding_dim]的参数矩阵，存储了所有可能的相对位置的嵌入向量\n",
    "        # F.embedding的作用是：对于relative_positions_matrix中的每个索引值i，查找self.relative_positions[i]，从而得到一个形状为[seq_len, seq_len, embedding_dim]的张量\n",
    "        # 这样，每对序列位置(i, j)就能获得它们的相对位置嵌入向量\n",
    "\n",
    "        # F.embedding会根据relative_positions_matrix中的每个索引，查找self.relative_positions中对应行的向量，\n",
    "        # 最终得到一个形状为[seq_len, seq_len, embedding_dim]的张量\n",
    "        # 具体来说，relative_positions_matrix的每个元素都是一个整数索引，表示相对位置\n",
    "        # F.embedding会用这些索引去self.relative_positions（形状[max_seq_len*2-1, embedding_dim]）中查找对应的嵌入向量\n",
    "        # 这样每对(i, j)位置就能获得它们的相对位置嵌入\n",
    "        relative_embeddings = F.embedding(relative_positions_matrix, self.relative_positions)\n",
    "        return relative_embeddings  # [seq_len, seq_len, embedding_dim]\n",
    "    \n",
    "    def _generate_relative_positions_matrix(self, seq_len: int):\n",
    "        range_vec = torch.arange(seq_len)  # 创建序列长度范围向量\n",
    "        range_matrix = range_vec.unsqueeze(0).expand(seq_len, seq_len)  # 扩展为矩阵\n",
    "        distance_matrix = range_matrix - range_matrix.t()  # 计算位置差距矩阵\n",
    "        distance_matrix = distance_matrix + self.max_seq_len - 1  # 将负值偏移为非负值\n",
    "        return distance_matrix  # 返回相对位置矩阵，[seq_len, seq_len]\n",
    "\n",
    "# 定义多头注意力模块\n",
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, embed_dim: int, num_heads: int, max_seq_len: int):\n",
    "        super().__init__()  # 调用父类初始化方法\n",
    "        self.embed_dim = embed_dim  # 嵌入维度\n",
    "        self.num_heads = num_heads  # 注意力头数\n",
    "        self.head_dim = embed_dim // num_heads  # 每个头的维度\n",
    "        self.q_proj = nn.Linear(embed_dim, embed_dim)  # 查询向量的线性投影\n",
    "        self.k_proj = nn.Linear(embed_dim, embed_dim)  # 键向量的线性投影\n",
    "        self.v_proj = nn.Linear(embed_dim, embed_dim)  # 值向量的线性投影\n",
    "        self.rel_pos_embeddings = RelativePositionEmbedding(max_seq_len, self.head_dim)  # 相对位置编码\n",
    "        self.out_proj = nn.Linear(embed_dim, embed_dim)  # 输出的线性投影\n",
    "    \n",
    "    def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor):\n",
    "        batch_size, seq_len, embed_dim = query.size()  # 获取输入张量的形状\n",
    "        \n",
    "        # 投影并重塑为多头形式\n",
    "        query = self.q_proj(query).view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch_size, num_heads, seq_len, head_dim)\n",
    "        key = self.k_proj(key).view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch_size, num_heads, seq_len, head_dim)\n",
    "        value = self.v_proj(value).view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch_size, num_heads, seq_len, head_dim)\n",
    "        \n",
    "        # 计算标准注意力分数\n",
    "        attention_scores = torch.matmul(query, key.transpose(-1, -2))  # (batch_size, num_heads, seq_len, seq_len)\n",
    "        \n",
    "        # 获取相对位置嵌入并添加到注意力分数中,走forward方法\n",
    "        # 调用self.rel_pos_embeddings的forward方法，传入当前序列长度seq_len，生成一个形状为(seq_len, seq_len, head_dim)的相对位置嵌入张量\n",
    "        # 这个张量的每个元素rel_pos_embeddings[i, j, :]表示序列中第i个位置和第j个位置之间的相对位置信息的嵌入向量\n",
    "        # 具体来说，self.rel_pos_embeddings是RelativePositionEmbedding类的实例，它根据输入的序列长度seq_len，先生成一个[seq_len, seq_len]的相对位置索引矩阵\n",
    "        # 然后通过F.embedding查找每对(i, j)的相对位置索引对应的嵌入向量，最终得到[seq_len, seq_len, head_dim]的三维张量\n",
    "        # 这样每对query和key的位置组合都能获得一组专属的相对位置编码，用于后续的相对位置注意力计算\n",
    "        rel_pos_embeddings = self.rel_pos_embeddings(seq_len)  # (seq_len, seq_len, head_dim)\n",
    "        \n",
    "        # 计算相对位置注意力分数\n",
    "        # 方法1：使用einsum进行高效计算\n",
    "        # 这行代码使用了torch.einsum函数来高效地计算相对位置注意力分数\n",
    "        # 'bhld,lrd->bhlr'是einsum的爱因斯坦求和约定字符串，含义如下：\n",
    "        # b: batch_size，h: num_heads，l: seq_len，d: head_dim，r: seq_len\n",
    "        # query的形状是(batch_size, num_heads, seq_len, head_dim)，即(b, h, l, d)\n",
    "        # rel_pos_embeddings的形状是(seq_len, seq_len, head_dim)，即(l, r, d)\n",
    "        # einsum的操作是：对于每个batch、每个头、每个query位置l和每个key位置r，\n",
    "        # 计算query[b, h, l, d]和rel_pos_embeddings[l, r, d]在d维上的点积\n",
    "        # 结果是(batch_size, num_heads, seq_len, seq_len)，即(b, h, l, r)\n",
    "        # 尺寸[batch_size, num_heads, 1, seq_len]\n",
    "        rel_attention_scores = torch.einsum('bhld,lrd->bhlr', query, rel_pos_embeddings)  # 计算每个query和所有key的相对位置注意力分数\n",
    "        \n",
    "        # 添加相对位置信息到注意力分数\n",
    "        attention_scores += rel_attention_scores\n",
    "        \n",
    "        # 缩放注意力分数\n",
    "        attention_scores = attention_scores / math.sqrt(self.head_dim)  # 缩放注意力分数\n",
    "        \n",
    "        # 计算注意力权重\n",
    "        attention_weights = F.softmax(attention_scores, dim=-1)  # 计算注意力权重\n",
    "        \n",
    "        # 应用注意力权重\n",
    "        output = torch.matmul(attention_weights, value)  # (batch_size, num_heads, seq_len, head_dim)\n",
    "        \n",
    "        # 重塑输出\n",
    "        output = output.transpose(1, 2).contiguous().view(batch_size, seq_len, embed_dim)  # (batch_size, seq_len, embed_dim)\n",
    "        \n",
    "        # 输出投影\n",
    "        output = self.out_proj(output)  # 输出投影\n",
    "        return output  # 返回最终输出\n",
    "\n",
    "# 示例使用\n",
    "max_seq_len = 10  # 设置最大序列长度\n",
    "embed_dim = 64  # 设置嵌入维度\n",
    "num_heads = 4  # 设置注意力头数\n",
    "batch_size = 2  # 设置批次大小\n",
    "seq_len = 5  # 设置序列长度\n",
    "\n",
    "query = torch.randn(batch_size, seq_len, embed_dim)  # 创建随机查询张量\n",
    "key = torch.randn(batch_size, seq_len, embed_dim)  # 创建随机键张量\n",
    "value = torch.randn(batch_size, seq_len, embed_dim)  # 创建随机值张量\n",
    "\n",
    "attention = MultiHeadAttention(embed_dim, num_heads, max_seq_len)  # 实例化多头注意力模块\n",
    "\n",
    "# 测试各个组件\n",
    "print(\"相对位置矩阵:\")\n",
    "print(attention.rel_pos_embeddings._generate_relative_positions_matrix(5))  # 打印相对位置矩阵\n",
    "print(f\"相对位置嵌入参数形状: {attention.rel_pos_embeddings.relative_positions.shape}\")  # 打印相对位置嵌入形状\n",
    "print(f\"序列长度为5的相对位置嵌入形状: {attention.rel_pos_embeddings(5).shape}\")  # 打印序列长度为5的相对位置嵌入形状\n",
    "\n",
    "# 计算注意力输出\n",
    "output = attention(query, key, value)  # 计算注意力输出\n",
    "print(f\"输出形状: {output.shape}\")  # 输出形状为 (batch_size, seq_len, embed_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d22a540",
   "metadata": {},
   "source": [
    "# 旋转位置编码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99c02578",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试旋转位置编码(RoPE)\n",
      "输入形状: torch.Size([2, 10, 128])\n",
      "输出形状: torch.Size([2, 10, 128])\n",
      "注意力权重形状: torch.Size([2, 8, 10, 10])\n",
      "\n",
      "测试相对位置特性:\n",
      "序列1注意力权重形状: torch.Size([1, 8, 5, 5])\n",
      "序列2注意力权重形状: torch.Size([1, 8, 7, 7])\n",
      "RoPE有助于保持序列中元素的相对位置关系\n",
      "\n",
      "比较RoPE与绝对位置编码:\n",
      "RoPE优势:\n",
      "1. 更好的相对位置建模\n",
      "2. 对序列长度的泛化能力更强\n",
      "3. 在长序列上性能更稳定\n",
      "\n",
      "绝对位置编码特点:\n",
      "1. 直接添加到输入embeddings\n",
      "2. 简单但可能丢失相对位置信息\n",
      "3. 对序列长度敏感\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "旋转位置编码(RoPE)示例完成！\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "class RotaryPositionalEmbedding(nn.Module):\n",
    "    \"\"\"\n",
    "    旋转位置编码(RoPE - Rotary Position Embedding)\n",
    "    \n",
    "    RoPE的核心思想是通过旋转矩阵来编码位置信息，相对于绝对位置编码，\n",
    "    RoPE能够更好地捕捉序列中元素的相对位置关系。\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, dim, max_position_embeddings=2048, base=10000):\n",
    "        super().__init__()\n",
    "        self.dim = dim  # 特征维度\n",
    "        self.max_position_embeddings = max_position_embeddings # 最大序列长度\n",
    "        self.base = base\n",
    "        \n",
    "        # 预计算频率\n",
    "        # 生成一个从0到dim-1，步长为2的整数序列，表示偶数索引的维度\n",
    "        # 例如，如果dim=8，则torch.arange(0, dim, 2)得到[0, 2, 4, 6]\n",
    "        # 将其转换为float类型，并除以总维度dim，得到每个偶数维度的归一化索引\n",
    "        # 以base为底，将上述归一化索引作为指数，计算base的幂\n",
    "        # 对每个结果取倒数，得到每个偶数维度的“倒频率”，用于后续的旋转位置编码\n",
    "        # 这样可以为每个偶数维度分配一个不同的频率，频率随维度递增而递减\n",
    "        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim)) \n",
    "        \n",
    "        # 使用register_buffer方法将inv_freq张量注册为模块的缓冲区，这样inv_freq会作为模型参数的一部分被保存和加载，但不会被优化器更新\n",
    "        # 这样做的目的是让inv_freq在模型保存、加载和迁移到不同设备（如GPU）时能够自动处理，无需手动管理\n",
    "        # 'inv_freq'是缓冲区的名称，inv_freq是预先计算好的倒频率张量，用于后续的旋转位置编码计算\n",
    "        self.register_buffer('inv_freq', inv_freq)\n",
    "        \n",
    "        # 预计算旋转矩阵\n",
    "        # 调用_set_cos_sin_cache方法，预先计算并缓存最大序列长度max_position_embeddings对应的cos和sin值，便于后续高效地进行旋转位置编码\n",
    "        self._set_cos_sin_cache(max_position_embeddings)\n",
    "    \n",
    "    def _set_cos_sin_cache(self, seq_len):\n",
    "        \"\"\"预计算cos和sin值\"\"\"\n",
    "        # 位置索引\n",
    "        # 创建一个长度为seq_len的整数序列，表示每个位置的索引（从0到seq_len-1）\n",
    "        # 该序列的数据类型与self.inv_freq相同，并且放在self.inv_freq所在的设备上（如CPU或GPU）\n",
    "        t = torch.arange(seq_len, dtype=self.inv_freq.dtype, device=self.inv_freq.device)\n",
    "        \n",
    "        # 计算角度: position * inv_freq\n",
    "        # 计算每个位置与每个频率的乘积，得到一个形状为[seq_len, dim//2]的二维张量\n",
    "        # 其中t是序列中的位置索引（长度为seq_len），self.inv_freq是每个偶数维度对应的倒频率（长度为dim//2）\n",
    "        # torch.outer(t, self.inv_freq)会对t中的每个位置与inv_freq中的每个频率做乘法，结果用于后续的正余弦编码\n",
    "        freqs = torch.outer(t, self.inv_freq)  # [seq_len, dim//2]\n",
    "        \n",
    "        # 拼接以匹配head_dim\n",
    "        # 将freqs张量在最后一个维度上拼接自身，得到形状为[seq_len, dim]的emb张量\n",
    "        # 这样做是因为RoPE需要将每个偶数和奇数维度分别对应同一个频率，实现后续的旋转操作\n",
    "        # 将freqs张量在最后一个维度上与自身拼接，得到一个新的张量emb，其形状为[seq_len, dim]\n",
    "        # 其中freqs的形状是[seq_len, dim//2]，表示每个位置和每个频率的乘积\n",
    "        # 通过torch.cat((freqs, freqs), dim=-1)，在最后一个维度（即特征维度）上将freqs复制一份并拼接\n",
    "        # 这样做的目的是将每个偶数和奇数维度都分配同样的频率，便于后续在RoPE中对每对相邻的特征维度进行旋转操作\n",
    "        # 例如，如果dim=8，则拼接后emb的形状为[seq_len, 8]，前4个维度和后4个维度的频率完全相同\n",
    "        emb = torch.cat((freqs, freqs), dim=-1)  # [seq_len, dim]\n",
    "        \n",
    "        # 缓存cos和sin值\n",
    "        self.register_buffer('cos_cached', emb.cos())  # [seq_len, dim]\n",
    "        self.register_buffer('sin_cached', emb.sin()) \n",
    "    \n",
    "    def forward(self, x, seq_len=None):\n",
    "        \"\"\"\n",
    "        应用旋转位置编码\n",
    "        \n",
    "        Args:\n",
    "            x: 输入张量 [batch_size, seq_len, num_heads, head_dim]\n",
    "            seq_len: 序列长度\n",
    "        \n",
    "        Returns:\n",
    "            应用RoPE后的张量\n",
    "        \"\"\"\n",
    "        if seq_len is None:\n",
    "            seq_len = x.shape[1]\n",
    "        \n",
    "        # 如果序列长度超过缓存，重新计算\n",
    "        if seq_len > self.cos_cached.shape[0]:\n",
    "            self._set_cos_sin_cache(seq_len)\n",
    "        \n",
    "        # 获取对应长度的cos和sin\n",
    "        cos = self.cos_cached[:seq_len]\n",
    "        sin = self.sin_cached[:seq_len]\n",
    "        \n",
    "        # 应用旋转位置编码\n",
    "        return self.apply_rotary_pos_emb(x, cos, sin)\n",
    "    \n",
    "    def apply_rotary_pos_emb(self, x, cos, sin):\n",
    "        \"\"\"应用旋转位置编码的核心函数\"\"\"\n",
    "        # x: [batch_size, seq_len, num_heads, head_dim]\n",
    "        # cos, sin: [seq_len, head_dim]\n",
    "        \n",
    "        # 调整cos和sin的维度以匹配x\n",
    "        # 从 [seq_len, head_dim] 扩展到 [1, seq_len, 1, head_dim]\n",
    "        cos = cos.unsqueeze(0).unsqueeze(2)  # [1, seq_len, 1, head_dim]\n",
    "        sin = sin.unsqueeze(0).unsqueeze(2)  # [1, seq_len, 1, head_dim]\n",
    "        \n",
    "        # 将x分成两部分进行旋转\n",
    "        # 将输入张量x在最后一个维度上分成两部分，x1为偶数索引的特征，x2为奇数索引的特征\n",
    "        # 这样做是为了后续将每对相邻的特征维度作为一组，进行旋转操作\n",
    "        x1, x2 = x[..., ::2], x[..., 1::2]\n",
    "        \n",
    "        # 旋转操作: 复数乘法的实现\n",
    "        # 下面实现了旋转位置编码的核心步骤，将输入的特征向量x分为偶数和奇数索引的两部分x1和x2\n",
    "        # 这里的x1代表偶数索引的特征，x2代表奇数索引的特征\n",
    "        # 旋转操作本质上等价于复数乘法：(a + bi) * (cosθ + sinθ*i) = (a*cosθ - b*sinθ) + (a*sinθ + b*cosθ)i\n",
    "        # 其中a对应x1，b对应x2，cosθ和sinθ分别是预先计算好的余弦和正弦位置编码\n",
    "        # 下面两行分别计算旋转后的偶数和奇数索引特征\n",
    "        rotated_x1 = x1 * cos[..., ::2] - x2 * sin[..., ::2]  # 计算旋转后偶数索引的特征分量\n",
    "        rotated_x2 = x1 * sin[..., 1::2] + x2 * cos[..., 1::2]  # 计算旋转后奇数索引的特征分量\n",
    "        \n",
    "        # 重新交错排列\n",
    "        rotated_x = torch.zeros_like(x)\n",
    "        # rotated_x1 的尺寸是 [batch_size, seq_len, num_heads, head_dim // 2]，与 rotated_x[..., ::2] 匹配\n",
    "        rotated_x[..., ::2] = rotated_x1  # 将旋转后的偶数索引特征分量放回对应位置\n",
    "        rotated_x[..., 1::2] = rotated_x2\n",
    "        \n",
    "        # 返回旋转后张量，尺寸为 [batch_size, seq_len, num_heads, head_dim]\n",
    "        return rotated_x\n",
    "\n",
    "class MultiHeadAttentionWithRoPE(nn.Module):\n",
    "    \"\"\"带有RoPE的多头注意力机制\"\"\"\n",
    "    \n",
    "    def __init__(self, d_model, num_heads, max_position_embeddings=2048):\n",
    "        super().__init__()\n",
    "        self.d_model = d_model\n",
    "        self.num_heads = num_heads\n",
    "        self.head_dim = d_model // num_heads\n",
    "        \n",
    "        assert self.head_dim * num_heads == d_model\n",
    "        \n",
    "        self.q_proj = nn.Linear(d_model, d_model)\n",
    "        self.k_proj = nn.Linear(d_model, d_model)\n",
    "        self.v_proj = nn.Linear(d_model, d_model)\n",
    "        self.o_proj = nn.Linear(d_model, d_model)\n",
    "        \n",
    "        # 旋转位置编码\n",
    "        # 创建一个旋转位置编码（RoPE）对象，用于为每个注意力头的特征维度生成旋转位置编码\n",
    "        # self.head_dim 表示每个注意力头的特征维度，max_position_embeddings 是支持的最大序列长度\n",
    "        self.rotary_emb = RotaryPositionalEmbedding(\n",
    "            self.head_dim, max_position_embeddings\n",
    "        )\n",
    "        \n",
    "        # 计算缩放因子，用于缩放注意力分数，防止在高维空间中点积值过大导致softmax梯度消失\n",
    "        self.scale = self.head_dim ** -0.5  # head_dim的-0.5次方等价于1/sqrt(head_dim)\n",
    "    \n",
    "    def forward(self, x, mask=None):\n",
    "        batch_size, seq_len, _ = x.shape\n",
    "        \n",
    "        # 线性变换\n",
    "        q = self.q_proj(x)\n",
    "        k = self.k_proj(x)\n",
    "        v = self.v_proj(x)\n",
    "        \n",
    "        # 重塑为多头\n",
    "        q = q.view(batch_size, seq_len, self.num_heads, self.head_dim)\n",
    "        k = k.view(batch_size, seq_len, self.num_heads, self.head_dim)\n",
    "        v = v.view(batch_size, seq_len, self.num_heads, self.head_dim)\n",
    "        \n",
    "        # 应用旋转位置编码\n",
    "        q = self.rotary_emb(q, seq_len)\n",
    "        k = self.rotary_emb(k, seq_len)\n",
    "        \n",
    "        # 转换维度用于注意力计算\n",
    "        q = q.transpose(1, 2)  # [batch_size, num_heads, seq_len, head_dim]\n",
    "        k = k.transpose(1, 2)\n",
    "        v = v.transpose(1, 2)\n",
    "        \n",
    "        # 计算注意力分数，公式:scores = Q * K.T/sqrt(d_k)\n",
    "        scores = torch.matmul(q, k.transpose(-2, -1)) * self.scale\n",
    "        \n",
    "        # 应用掩码\n",
    "        if mask is not None:\n",
    "            scores = scores.masked_fill(mask == 0, -1e9)\n",
    "        \n",
    "        # 注意力权重\n",
    "        attn_weights = torch.softmax(scores, dim=-1)\n",
    "        \n",
    "        # 应用注意力权重\n",
    "        attn_output = torch.matmul(attn_weights, v)\n",
    "        \n",
    "        # 重新组合头\n",
    "        attn_output = attn_output.transpose(1, 2).contiguous().view(\n",
    "            batch_size, seq_len, self.d_model\n",
    "        )\n",
    "        \n",
    "        # 输出投影\n",
    "        output = self.o_proj(attn_output)\n",
    "        \n",
    "        return output, attn_weights\n",
    "\n",
    "def visualize_rope():\n",
    "    \"\"\"可视化RoPE的频率特性\"\"\"\n",
    "    dim = 64\n",
    "    max_len = 100\n",
    "    \n",
    "    rope = RotaryPositionalEmbedding(dim, max_len)\n",
    "    \n",
    "    # 创建示例输入\n",
    "    x = torch.randn(1, max_len, 1, dim) # [batch_size, seq_len, num_heads, dim]\n",
    "    \n",
    "    # 应用RoPE\n",
    "    rotated_x = rope(x)\n",
    "    \n",
    "    # 可视化频率\n",
    "    plt.figure(figsize=(12, 8))\n",
    "    \n",
    "    # 绘制频率分布\n",
    "    plt.subplot(2, 2, 1)\n",
    "    plt.plot(rope.inv_freq.numpy())\n",
    "    plt.title('Inverse Frequencies')\n",
    "    plt.xlabel('Dimension Index')\n",
    "    plt.ylabel('Inverse Frequency')\n",
    "    \n",
    "    # 绘制cos值\n",
    "    plt.subplot(2, 2, 2)\n",
    "    cos_matrix = rope.cos_cached[:50, :32].numpy()\n",
    "    plt.imshow(cos_matrix, cmap='RdBu', aspect='auto')\n",
    "    plt.title('Cosine Values (First 32 dims, 50 positions)')\n",
    "    plt.xlabel('Dimension')\n",
    "    plt.ylabel('Position')\n",
    "    plt.colorbar()\n",
    "    \n",
    "    # 绘制sin值\n",
    "    plt.subplot(2, 2, 3)\n",
    "    sin_matrix = rope.sin_cached[:50, :32].numpy()\n",
    "    plt.imshow(sin_matrix, cmap='RdBu', aspect='auto')\n",
    "    plt.title('Sine Values (First 32 dims, 50 positions)')\n",
    "    plt.xlabel('Dimension')\n",
    "    plt.ylabel('Position')\n",
    "    plt.colorbar()\n",
    "    \n",
    "    # 绘制旋转角度随位置的变化\n",
    "    plt.subplot(2, 2, 4)\n",
    "    positions = torch.arange(50)\n",
    "    angles = torch.einsum('i,j->ij', positions.float(), rope.inv_freq[:8])\n",
    "    for i in range(8):\n",
    "        plt.plot(positions, angles[:, i], label=f'dim {i*2}')\n",
    "    plt.title('Rotation Angles vs Position')\n",
    "    plt.xlabel('Position')\n",
    "    plt.ylabel('Angle (radians)')\n",
    "    plt.legend()\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "def test_rope_example():\n",
    "    \"\"\"测试RoPE的基本功能\"\"\"\n",
    "    print(\"测试旋转位置编码(RoPE)\")\n",
    "    \n",
    "    # 参数设置\n",
    "    batch_size = 2\n",
    "    seq_len = 10\n",
    "    d_model = 128\n",
    "    num_heads = 8\n",
    "    \n",
    "    # 创建模型\n",
    "    attention = MultiHeadAttentionWithRoPE(d_model, num_heads)\n",
    "    \n",
    "    # 创建输入\n",
    "    x = torch.randn(batch_size, seq_len, d_model)\n",
    "    \n",
    "    # 前向传播\n",
    "    output, attn_weights = attention(x)\n",
    "    \n",
    "    print(f\"输入形状: {x.shape}\")\n",
    "    print(f\"输出形状: {output.shape}\")\n",
    "    print(f\"注意力权重形状: {attn_weights.shape}\")\n",
    "    \n",
    "    # 测试相对位置特性\n",
    "    print(\"\\n测试相对位置特性:\")\n",
    "    \n",
    "    # 创建两个序列：一个是另一个的平移版本\n",
    "    seq1 = torch.randn(1, 5, d_model)\n",
    "    seq2 = torch.cat([torch.zeros(1, 2, d_model), seq1], dim=1)  # 向右平移2位\n",
    "    \n",
    "    # 计算注意力\n",
    "    _, attn1 = attention(seq1)\n",
    "    _, attn2 = attention(seq2)\n",
    "    \n",
    "    print(f\"序列1注意力权重形状: {attn1.shape}\")\n",
    "    print(f\"序列2注意力权重形状: {attn2.shape}\")\n",
    "    \n",
    "    # RoPE应该保持相对位置关系\n",
    "    print(\"RoPE有助于保持序列中元素的相对位置关系\")\n",
    "\n",
    "def compare_with_absolute_pe():\n",
    "    \"\"\"比较RoPE与绝对位置编码\"\"\"\n",
    "    print(\"\\n比较RoPE与绝对位置编码:\")\n",
    "    \n",
    "    d_model = 64\n",
    "    seq_len = 20\n",
    "    \n",
    "    # 创建RoPE\n",
    "    rope = RotaryPositionalEmbedding(d_model, seq_len)\n",
    "    \n",
    "    # 创建绝对位置编码\n",
    "    position = torch.arange(seq_len).unsqueeze(1) \n",
    "    div_term = torch.exp(torch.arange(0, d_model, 2) * \n",
    "                        (-math.log(10000.0) / d_model))\n",
    "    \n",
    "    abs_pe = torch.zeros(seq_len, d_model)\n",
    "    abs_pe[:, 0::2] = torch.sin(position * div_term) # 偶数位置\n",
    "    abs_pe[:, 1::2] = torch.cos(position * div_term) # 奇数位置\n",
    "    \n",
    "    print(\"RoPE优势:\")\n",
    "    print(\"1. 更好的相对位置建模\")\n",
    "    print(\"2. 对序列长度的泛化能力更强\")\n",
    "    print(\"3. 在长序列上性能更稳定\")\n",
    "    \n",
    "    print(\"\\n绝对位置编码特点:\")\n",
    "    print(\"1. 直接添加到输入embeddings\")\n",
    "    print(\"2. 简单但可能丢失相对位置信息\")\n",
    "    print(\"3. 对序列长度敏感\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # 运行测试\n",
    "    test_rope_example()\n",
    "    \n",
    "    # 比较不同位置编码方法\n",
    "    compare_with_absolute_pe()\n",
    "    \n",
    "    # 可视化（需要matplotlib）\n",
    "    try:\n",
    "        visualize_rope()\n",
    "    except ImportError:\n",
    "        print(\"需要安装matplotlib来运行可视化: pip install matplotlib\")\n",
    "    \n",
    "    print(\"\\n旋转位置编码(RoPE)示例完成！\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
